home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / grafik / converter / limbo4.0 / src / 3d / fileio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  9.6 KB  |  301 lines
  1. #include "includes.h"
  2.  
  3.  Parameter *FileIO_Parm;
  4.  
  5. /**************************************|****************************************
  6. Routine   : SaveTrans
  7. Input  par: Transformation *T (pointer to trans)
  8.             char *file        (filename)
  9.             int dx            (delta x)
  10.             int dy            (delta y)
  11. Output par: none
  12. Function  : Saves transformation plus all its sub-transformation.
  13. ***************************************|***************************************/
  14.  
  15.  void SaveTrans3D(Transformation *T,char *file, int delta)
  16.   {
  17.    unsigned char out[]="dummy",temp,main=TRUE;
  18.    unsigned int i,j,k;
  19.    
  20.    if (T->Sub!=NULL) main=FALSE; /* check subblock configuration */
  21.    
  22.    out[0]=main;
  23.    IOBitArray(FILE_APPEND,file,FileIO_Parm->SBits,out); /* par/subs */
  24.    
  25.    if (main) /* should we save the transformation ? */
  26.     {
  27.      switch(T->Type)
  28.       {
  29.        case EDGEBLOCK : 
  30.        out[0]=0x00;  /* Type bit = 00 b */
  31.        IOBitArray(FILE_APPEND,file,1,out);
  32.        out[0]=(unsigned char)(T->Domain->x/delta);
  33.        IOBitArray(FILE_APPEND,file,FileIO_Parm->XBits,out);
  34.        out[0]=(unsigned char)(T->Domain->y/delta);
  35.        IOBitArray(FILE_APPEND,file,FileIO_Parm->YBits,out);
  36.        out[0]=(unsigned char)(T->Domain->z/delta);
  37.        IOBitArray(FILE_APPEND,file,FileIO_Parm->ZBits,out);
  38.        out[0]=MakeRange(T->Alpha,FileIO_Parm);
  39.        IOBitArray(FILE_APPEND,file,FileIO_Parm->ABits,out);
  40.        
  41.        if (T->Deltag<0) 
  42.         {
  43.          temp=-T->Deltag;
  44.          out[0]=1;
  45.         }
  46.        else 
  47.         {
  48.          temp=T->Deltag;
  49.          out[0]=0;
  50.         }
  51.        IOBitArray(FILE_APPEND,file,1,out); /* save sign */
  52.        out[0]=temp;
  53.        IOBitArray(FILE_APPEND,file,FileIO_Parm->DBits,out);
  54.        
  55.        out[0]=(unsigned char)(T->tn);
  56.        IOBitArray(FILE_APPEND,file,FileIO_Parm->TBits,out);
  57.        break;
  58.        
  59.        case SHADEBLOCK :
  60.        out[0]=0x01;  /* Type bit = 10 b */
  61.        IOBitArray(FILE_APPEND,file,1,out);
  62.        out[0]=(unsigned char)(T->g0);
  63.        IOBitArray(FILE_APPEND,file,FileIO_Parm->GBits,out);
  64.        break;
  65.        
  66.        default : ErrorHandler(OUT_OF_RANGE,"Unknown block type in SaveFC");
  67.        break;
  68.       }
  69.     }
  70.    else
  71.    for(i=0;i<2;i++)
  72.    for(j=0;j<2;j++)
  73.    for(k=0;k<2;k++) SaveTrans3D(T->Sub[i][j][k],file,delta);
  74.    
  75.   }
  76.  
  77. /**************************************|****************************************
  78. Routine   : SaveFC
  79. Input  par: Transformation ***T (pointer to 2D array of Transformation pointers)
  80.             char *file          (filename)
  81.             LimboHeader TheHead (header structure with current header info)
  82. Output par: none
  83. Function  : Saves all transformation in T[][] to file. Saves FC-header + FC-Code
  84. ***************************************|***************************************/
  85.  
  86.  void SaveFC3D(Transformation ****T, char *file, LimboHeader *Head)
  87.   {
  88.    int i,j,k,x,y,z,delta,B,nsquare;
  89.    unsigned char out[]="dummy";
  90.    char savefile[99];
  91.    FILE *headfile;
  92.    
  93.    strcpy(savefile,FCCODE);
  94.    strcat(savefile,file);
  95.    strcat(savefile,".lmb");
  96.    
  97.    vprintf(stderr,"\nSaving fractal code...\n   File:'%s'",savefile);
  98.    
  99.    HeadInfo3D(T,Head);
  100.    
  101.    FileIO_Parm=GimmeAParameter();
  102.    FileIO_Parm->XBits=Head->XBits;
  103.    FileIO_Parm->YBits=Head->YBits;
  104.    FileIO_Parm->ZBits=Head->ZBits;
  105.    FileIO_Parm->SBits=Head->SBits;
  106.    FileIO_Parm->ABits=Head->ABits;
  107.    FileIO_Parm->AMax =Head->AMax/100.0;
  108.    FileIO_Parm->AMin =Head->AMin/100.0;
  109.    FileIO_Parm->DBits=Head->DBits;
  110.    FileIO_Parm->GBits=Head->GBits;
  111.    FileIO_Parm->TBits=Head->TBits;
  112.    
  113.    x=Head->MSBx*256+Head->LSBx;
  114.    y=Head->MSBy*256+Head->LSBy;
  115.    z=Head->MSBz*256+Head->LSBz;
  116.    delta=Head->Delta;
  117.    B=Head->B;
  118.    nsquare=Head->NSquare;
  119.    
  120.    if ((headfile=fopen(savefile,"wb")) == NULL) 
  121.    ErrorHandler(UNABLE_TO_OPEN,"SaveFC could not open file");
  122.    fprintf(headfile,"LIMBO:%s\n",LIMBOVERSION);
  123.    fwrite((void *)Head,sizeof(LimboHeader),1,headfile);
  124.    if (fclose(headfile)) ErrorHandler(UNABLE_TO_CLOSE,"SaveFC could not close file");
  125.    
  126.    IOBitArray(FILE_OPENAPPEND,savefile,0,out); /* open for FCCode */
  127.    for (i=0;i<x/(B<<nsquare);i++)  
  128.    for (j=0;j<y/(B<<nsquare);j++)
  129.    for (k=0;k<z/(B<<nsquare);k++)
  130.    SaveTrans3D(T[i][j][k],savefile,delta);  /* save transformations */
  131.    
  132.    out[0]='X';
  133.    IOBitArray(FILE_APPEND,file,8,out); /* end */
  134.    IOBitArray(FILE_CLOSE,savefile,0,out);
  135.   }
  136.  
  137. /**************************************|****************************************
  138. Routine   : LoadTrans
  139. Input  par: char *file (filename)
  140.             int B      (B-blocksize)
  141.             int D      (D-blocksize)
  142.             int dx     (delta x)
  143.             int dy     (delta y)
  144. Output par: Transformation * (pointer to transformation loaded)
  145. Function  : Loads transformation from file. Loads main transformation plus 
  146.             recursive load of all sub-blocks.
  147. ***************************************|***************************************/
  148.  
  149.  Transformation *LoadTrans3D(char *file, int B, int D, int delta)
  150.   {
  151.    Transformation *T;
  152.    unsigned char in[99],sign,main=TRUE;
  153.    int type;
  154.    
  155.    T=GimmeATransformation();    /*dynamic allocation of tranformation */
  156.    T->Type=NOBLOCK;
  157.    T->D=D;
  158.    T->BlockSize=B;
  159.    
  160.    if (FileIO_Parm->SBits) 
  161.     {
  162.      IOBitArray(FILE_READ,file,FileIO_Parm->SBits,in); /* parent/sub bit */
  163.      main=in[0]; /* remember subblock */ 
  164.     }
  165.    
  166.    if (main) /* read trans ? if this is a main */               
  167.     {
  168.      T->Domain=GimmeAPoolNode();
  169.      
  170.      IOBitArray(FILE_READ,file,1,in);
  171.      if (in[0]==0x00)      type=EDGEBLOCK;
  172.      else if (in[0]==0x01) type=SHADEBLOCK;
  173.      else ErrorHandler(OUT_OF_RANGE,"Unknown block type in LoadFC");
  174.      
  175.      switch(type)
  176.       {
  177.        case EDGEBLOCK :
  178.        T->Type=EDGEBLOCK;
  179.        T->D=D;
  180.        T->BlockSize=B;
  181.        IOBitArray(FILE_READ,file,FileIO_Parm->XBits,in);
  182.        T->Domain->x=in[0]*delta;
  183.        IOBitArray(FILE_READ,file,FileIO_Parm->YBits,in);
  184.        T->Domain->y=in[0]*delta;
  185.        IOBitArray(FILE_READ,file,FileIO_Parm->ZBits,in);
  186.        T->Domain->z=in[0]*delta;
  187.        IOBitArray(FILE_READ,file,FileIO_Parm->ABits,in);
  188.        T->Alpha=MakeFloat(in[0],FileIO_Parm);
  189.        
  190.        IOBitArray(FILE_READ,file,1,in);
  191.        sign=in[0];
  192.        IOBitArray(FILE_READ,file,FileIO_Parm->DBits,in);
  193.        if (sign==0) T->Deltag=in[0];
  194.        else T->Deltag = -in[0];
  195.        
  196.        IOBitArray(FILE_READ,file,FileIO_Parm->TBits,in);
  197.        T->tn=in[0];
  198.        break;
  199.        
  200.        case SHADEBLOCK :
  201.        T->Type=SHADEBLOCK;
  202.        T->D=D;
  203.        T->BlockSize=B;
  204.        IOBitArray(FILE_READ,file,FileIO_Parm->GBits,in);
  205.        T->g0=(int)in[0];
  206.        break;
  207.        
  208.        default : ErrorHandler(OUT_OF_RANGE,"Unknown block type in LoadFC");
  209.        break;
  210.       }
  211.     }
  212.    else /* load subblock configuration */
  213.     {
  214.      int i,j,k;
  215.      T->Sub=GimmeATransArray3D(2,2,2);
  216.      
  217.      for(i=0;i<2;i++) 
  218.      for(j=0;j<2;j++) 
  219.      for(k=0;k<2;k++) T->Sub[i][j][k]=LoadTrans3D(file,B>>1,D>>1,delta);
  220.     }
  221.    
  222.    return T;
  223.   }
  224.  
  225. /**************************************|****************************************
  226. Routine   : LoadFC
  227. Input  par: Transformation ***T (pointer to 2D array of Transformation pointers,
  228.                                  will be filled with the loaded transformations)
  229.             char *file          (filename)
  230.             int infoflag        (fractal code info for file flag. 1=info 0=noinfo)
  231. Output par: LimboHeader Head (header structure with new file info)
  232. Function  : Reads FC-code from file. Read FC Header. Allocates transformations.
  233.             Reads p/c configuration plus fractal code. Stores code in allocated
  234.             transformations. Returns header structure with file info.
  235. ****************************************|***************************************/
  236.  
  237.  LimboHeader *LoadFC3D(Transformation *****T, char *file)
  238.   {
  239.    FILE *infile;
  240.    int i,j,k,x,y,z,delta,size,B,nsquare;
  241.    unsigned char in[99],limbo[20];
  242.    char loadfile[99];
  243.    LimboHeader *Head=GimmeALimboHeader();
  244.    
  245.    strcpy(loadfile,FCCODE);
  246.    strcat(loadfile,file);
  247.    strcat(loadfile,".lmb");
  248.    
  249.    vprintf(stderr,"\nLoading fractal code...\n   File:'%s'",loadfile);
  250.    
  251.    if ((infile=fopen(loadfile,"rb")) == NULL)
  252.    ErrorHandler(UNABLE_TO_OPEN,"LoadFC could not open file");
  253.    fgets(limbo,LIMBOSTRINGSIZE,infile);             /* read version */
  254.    
  255.    if ((strncmp(limbo,"LIMBO:",5))) 
  256.     {
  257.      char msg[40];
  258.      strcpy(msg,"Could not read file ");
  259.      strcat(msg,loadfile);
  260.      ErrorHandler(UNKNOWN_FORMAT,msg);
  261.     }
  262.    vprintf(stderr,"\n   Version: %s",limbo);
  263.    fread(Head,sizeof(LimboHeader),1,infile);    /* read header */
  264.    
  265.    size=Head->HeadSize;
  266.    
  267.    FileIO_Parm=GimmeAParameter();
  268.    FileIO_Parm->XBits=Head->XBits;
  269.    FileIO_Parm->YBits=Head->YBits;
  270.    FileIO_Parm->ZBits=Head->ZBits;
  271.    FileIO_Parm->SBits=Head->SBits;
  272.    FileIO_Parm->ABits=Head->ABits;
  273.    FileIO_Parm->AMax =Head->AMax/100.0;
  274.    FileIO_Parm->AMin =Head->AMin/100.0;
  275.    FileIO_Parm->DBits=Head->DBits;
  276.    FileIO_Parm->GBits=Head->GBits;
  277.    FileIO_Parm->TBits=Head->TBits;
  278.    
  279.    x=Head->MSBx*256+Head->LSBx;
  280.    y=Head->MSBy*256+Head->LSBy;
  281.    z=Head->MSBz*256+Head->LSBz;
  282.    delta=Head->Delta;
  283.    B=Head->B;
  284.    nsquare=Head->NSquare;
  285.    *T=GimmeATransArray3D(x/(B<<nsquare),y/(B<<nsquare),z/(B<<nsquare));
  286.    
  287.    IOBitArray(FILE_OPENREAD,loadfile,0,in);
  288.    IOBitArray(FILE_READ,loadfile,size*8-8,in);  /* skip header */
  289.    
  290.    for (i=0;i<x/(B<<nsquare);i++)
  291.    for (j=0;j<y/(B<<nsquare);j++)
  292.    for (k=0;k<z/(B<<nsquare);k++) 
  293.    (*T)[i][j][k]=LoadTrans3D(loadfile,B<<nsquare,B<<(nsquare+1),delta);
  294.    
  295.    IOBitArray(FILE_READ,file,8,in); /* end */
  296.    if (in[0]!='X') ErrorHandler(ERROR_READING,"LoadFC could not find tail in FCfile");
  297.    IOBitArray(FILE_CLOSE,loadfile,0,in);
  298.    
  299.    return Head;
  300.   }
  301.